/**
 * This is a generated class and is not intended for modification.  To customize behavior
 * of this service wrapper you may modify the generated sub-class of this class - Jira.as.
 */
package services.jira
{
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.services.wrapper.WebServiceWrapper;
import com.adobe.serializers.utility.TypeUtility;
import mx.collections.ArrayCollection;
import mx.rpc.AbstractOperation;
import mx.rpc.AsyncToken;
import mx.rpc.soap.mxml.Operation;
import mx.rpc.soap.mxml.WebService;
import valueObjects.RemoteAttachment;
import valueObjects.RemoteAvatar;
import valueObjects.RemoteComment;
import valueObjects.RemoteComponent;
import valueObjects.RemoteConfiguration;
import valueObjects.RemoteEntity;
import valueObjects.RemoteField;
import valueObjects.RemoteFilter;
import valueObjects.RemoteGroup;
import valueObjects.RemoteIssue;
import valueObjects.RemoteIssueType;
import valueObjects.RemoteNamedObject;
import valueObjects.RemotePermission;
import valueObjects.RemotePermissionScheme;
import valueObjects.RemotePriority;
import valueObjects.RemoteProject;
import valueObjects.RemoteProjectRole;
import valueObjects.RemoteProjectRoleActors;
import valueObjects.RemoteResolution;
import valueObjects.RemoteRoleActors;
import valueObjects.RemoteScheme;
import valueObjects.RemoteSecurityLevel;
import valueObjects.RemoteServerInfo;
import valueObjects.RemoteStatus;
import valueObjects.RemoteUser;
import valueObjects.RemoteVersion;
import valueObjects.RemoteWorklog;

[ExcludeClass]
internal class _Super_Jira extends com.adobe.fiber.services.wrapper.WebServiceWrapper
{
    
    // Constructor
    public function _Super_Jira()
    {
        // initialize service control
        _serviceControl = new mx.rpc.soap.mxml.WebService();
        var operations:Object = new Object();
        var operation:mx.rpc.soap.mxml.Operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssuesFromFilterWithLimit");
         operation.resultElementType = valueObjects.RemoteIssue;
        operations["getIssuesFromFilterWithLimit"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssuesFromJqlSearch");
         operation.resultElementType = valueObjects.RemoteIssue;
        operations["getIssuesFromJqlSearch"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getVersions");
         operation.resultElementType = valueObjects.RemoteVersion;
        operations["getVersions"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getConfiguration");
         operation.resultType = valueObjects.RemoteConfiguration;
        operations["getConfiguration"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "progressWorkflowAction");
         operation.resultType = valueObjects.RemoteIssue;
        operations["progressWorkflowAction"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createProjectFromObject");
         operation.resultType = valueObjects.RemoteProject;
        operations["createProjectFromObject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getGroup");
         operation.resultType = valueObjects.RemoteGroup;
        operations["getGroup"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addBase64EncodedAttachmentsToIssue");
         operation.resultType = Boolean;
        operations["addBase64EncodedAttachmentsToIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateProject");
         operation.resultType = valueObjects.RemoteProject;
        operations["updateProject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addWorklogAndRetainRemainingEstimate");
         operation.resultType = valueObjects.RemoteWorklog;
        operations["addWorklogAndRetainRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteWorklogAndAutoAdjustRemainingEstimate");
        operations["deleteWorklogAndAutoAdjustRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteUser");
        operations["deleteUser"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteProjectRole");
        operations["deleteProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "removeAllRoleActorsByNameAndType");
        operations["removeAllRoleActorsByNameAndType"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectByKey");
         operation.resultType = valueObjects.RemoteProject;
        operations["getProjectByKey"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectsNoSchemes");
         operation.resultElementType = valueObjects.RemoteProject;
        operations["getProjectsNoSchemes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "setNewProjectAvatar");
        operations["setNewProjectAvatar"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssueTypesForProject");
         operation.resultElementType = valueObjects.RemoteIssueType;
        operations["getIssueTypesForProject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getCustomFields");
         operation.resultElementType = valueObjects.RemoteField;
        operations["getCustomFields"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "isProjectRoleNameUnique");
         operation.resultType = Boolean;
        operations["isProjectRoleNameUnique"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getDefaultRoleActors");
         operation.resultType = valueObjects.RemoteRoleActors;
        operations["getDefaultRoleActors"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getComponents");
         operation.resultElementType = valueObjects.RemoteComponent;
        operations["getComponents"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createPermissionScheme");
         operation.resultType = valueObjects.RemotePermissionScheme;
        operations["createPermissionScheme"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getAssociatedPermissionSchemes");
         operation.resultElementType = valueObjects.RemoteScheme;
        operations["getAssociatedPermissionSchemes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectAvatars");
         operation.resultElementType = valueObjects.RemoteAvatar;
        operations["getProjectAvatars"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteWorklogWithNewRemainingEstimate");
        operations["deleteWorklogWithNewRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addVersion");
         operation.resultType = valueObjects.RemoteVersion;
        operations["addVersion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getSubTaskIssueTypesForProject");
         operation.resultElementType = valueObjects.RemoteIssueType;
        operations["getSubTaskIssueTypesForProject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getNotificationSchemes");
         operation.resultElementType = valueObjects.RemoteScheme;
        operations["getNotificationSchemes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addAttachmentsToIssue");
         operation.resultType = Boolean;
        operations["addAttachmentsToIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "hasPermissionToDeleteWorklog");
         operation.resultType = Boolean;
        operations["hasPermissionToDeleteWorklog"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "refreshCustomFields");
        operations["refreshCustomFields"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createProject");
         operation.resultType = valueObjects.RemoteProject;
        operations["createProject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateWorklogAndAutoAdjustRemainingEstimate");
        operations["updateWorklogAndAutoAdjustRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addWorklogWithNewRemainingEstimate");
         operation.resultType = valueObjects.RemoteWorklog;
        operations["addWorklogWithNewRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addPermissionTo");
         operation.resultType = valueObjects.RemotePermissionScheme;
        operations["addPermissionTo"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateWorklogWithNewRemainingEstimate");
        operations["updateWorklogWithNewRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "login");
         operation.resultType = String;
        operations["login"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssuesFromTextSearchWithProject");
         operation.resultElementType = valueObjects.RemoteIssue;
        operations["getIssuesFromTextSearchWithProject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addComment");
        operations["addComment"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getSubTaskIssueTypes");
         operation.resultElementType = valueObjects.RemoteIssueType;
        operations["getSubTaskIssueTypes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssueTypes");
         operation.resultElementType = valueObjects.RemoteIssueType;
        operations["getIssueTypes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getFieldsForAction");
         operation.resultElementType = valueObjects.RemoteField;
        operations["getFieldsForAction"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectWithSchemesById");
         operation.resultType = valueObjects.RemoteProject;
        operations["getProjectWithSchemesById"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getAvailableActions");
         operation.resultElementType = valueObjects.RemoteNamedObject;
        operations["getAvailableActions"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "removeUserFromGroup");
        operations["removeUserFromGroup"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssuesFromFilter");
         operation.resultElementType = valueObjects.RemoteIssue;
        operations["getIssuesFromFilter"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "setProjectAvatar");
        operations["setProjectAvatar"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getSecurityLevels");
         operation.resultElementType = valueObjects.RemoteSecurityLevel;
        operations["getSecurityLevels"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getResolutionDateById");
         operation.resultType = Date;
        operations["getResolutionDateById"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addUserToGroup");
        operations["addUserToGroup"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectRole");
         operation.resultType = valueObjects.RemoteProjectRole;
        operations["getProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deletePermissionScheme");
        operations["deletePermissionScheme"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createIssueWithSecurityLevel");
         operation.resultType = valueObjects.RemoteIssue;
        operations["createIssueWithSecurityLevel"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssuesFromTextSearch");
         operation.resultElementType = valueObjects.RemoteIssue;
        operations["getIssuesFromTextSearch"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getSavedFilters");
         operation.resultElementType = valueObjects.RemoteFilter;
        operations["getSavedFilters"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteIssue");
        operations["deleteIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "hasPermissionToCreateWorklog");
         operation.resultType = Boolean;
        operations["hasPermissionToCreateWorklog"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "hasPermissionToUpdateWorklog");
         operation.resultType = Boolean;
        operations["hasPermissionToUpdateWorklog"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addWorklogAndAutoAdjustRemainingEstimate");
         operation.resultType = valueObjects.RemoteWorklog;
        operations["addWorklogAndAutoAdjustRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectAvatar");
         operation.resultType = valueObjects.RemoteAvatar;
        operations["getProjectAvatar"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addActorsToProjectRole");
        operations["addActorsToProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "logout");
         operation.resultType = Boolean;
        operations["logout"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getWorklogs");
         operation.resultElementType = valueObjects.RemoteWorklog;
        operations["getWorklogs"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectById");
         operation.resultType = valueObjects.RemoteProject;
        operations["getProjectById"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getAllPermissions");
         operation.resultElementType = valueObjects.RemotePermission;
        operations["getAllPermissions"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getFieldsForEdit");
         operation.resultElementType = valueObjects.RemoteField;
        operations["getFieldsForEdit"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createUser");
         operation.resultType = valueObjects.RemoteUser;
        operations["createUser"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "removeDefaultActorsFromProjectRole");
        operations["removeDefaultActorsFromProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssue");
         operation.resultType = valueObjects.RemoteIssue;
        operations["getIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateProjectRole");
        operations["updateProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "archiveVersion");
        operations["archiveVersion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "removeActorsFromProjectRole");
        operations["removeActorsFromProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectRoles");
         operation.resultElementType = valueObjects.RemoteProjectRole;
        operations["getProjectRoles"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateGroup");
         operation.resultType = valueObjects.RemoteGroup;
        operations["updateGroup"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getUser");
         operation.resultType = valueObjects.RemoteUser;
        operations["getUser"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getAssociatedNotificationSchemes");
         operation.resultElementType = valueObjects.RemoteScheme;
        operations["getAssociatedNotificationSchemes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssueById");
         operation.resultType = valueObjects.RemoteIssue;
        operations["getIssueById"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteGroup");
        operations["deleteGroup"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getFavouriteFilters");
         operation.resultElementType = valueObjects.RemoteFilter;
        operations["getFavouriteFilters"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getComments");
         operation.resultElementType = valueObjects.RemoteComment;
        operations["getComments"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "addDefaultActorsToProjectRole");
        operations["addDefaultActorsToProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createIssue");
         operation.resultType = valueObjects.RemoteIssue;
        operations["createIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getComment");
         operation.resultType = valueObjects.RemoteComment;
        operations["getComment"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getSecurityLevel");
         operation.resultType = valueObjects.RemoteSecurityLevel;
        operations["getSecurityLevel"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "removeAllRoleActorsByProject");
        operations["removeAllRoleActorsByProject"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getProjectRoleActors");
         operation.resultType = valueObjects.RemoteProjectRoleActors;
        operations["getProjectRoleActors"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteProjectAvatar");
        operations["deleteProjectAvatar"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "editComment");
         operation.resultType = valueObjects.RemoteComment;
        operations["editComment"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getPermissionSchemes");
         operation.resultElementType = valueObjects.RemotePermissionScheme;
        operations["getPermissionSchemes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "releaseVersion");
        operations["releaseVersion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getPriorities");
         operation.resultElementType = valueObjects.RemotePriority;
        operations["getPriorities"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createGroup");
         operation.resultType = valueObjects.RemoteGroup;
        operations["createGroup"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateIssue");
         operation.resultType = valueObjects.RemoteIssue;
        operations["updateIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deletePermissionFrom");
         operation.resultType = valueObjects.RemotePermissionScheme;
        operations["deletePermissionFrom"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssueCountForFilter");
         operation.resultType = Number;
        operations["getIssueCountForFilter"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteWorklogAndRetainRemainingEstimate");
        operations["deleteWorklogAndRetainRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getResolutionDateByKey");
         operation.resultType = Date;
        operations["getResolutionDateByKey"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getAttachmentsFromIssue");
         operation.resultElementType = valueObjects.RemoteAttachment;
        operations["getAttachmentsFromIssue"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "hasPermissionToEditComment");
         operation.resultType = Boolean;
        operations["hasPermissionToEditComment"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "updateWorklogAndRetainRemainingEstimate");
        operations["updateWorklogAndRetainRemainingEstimate"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getServerInfo");
         operation.resultType = valueObjects.RemoteServerInfo;
        operations["getServerInfo"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "createProjectRole");
         operation.resultType = valueObjects.RemoteProjectRole;
        operations["createProjectRole"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getIssuesFromTextSearchWithLimit");
         operation.resultElementType = valueObjects.RemoteIssue;
        operations["getIssuesFromTextSearchWithLimit"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getStatuses");
         operation.resultElementType = valueObjects.RemoteStatus;
        operations["getStatuses"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getSecuritySchemes");
         operation.resultElementType = valueObjects.RemoteScheme;
        operations["getSecuritySchemes"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getResolutions");
         operation.resultElementType = valueObjects.RemoteResolution;
        operations["getResolutions"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "deleteProject");
        operations["deleteProject"] = operation;

        _serviceControl.operations = operations;
        try
        {
            _serviceControl.convertResultHandler = com.adobe.serializers.utility.TypeUtility.convertResultHandler;
        }
        catch (e: Error)
        { /* Flex 3.4 and earlier does not support the convertResultHandler functionality. */ }


        preInitializeService();
        model_internal::initialize();
    }
    
    //init initialization routine here, child class to override
    protected function preInitializeService():void
    {


        _serviceControl.service = "JiraSoapServiceService";
        _serviceControl.port = "jirasoapservice-v2";
        wsdl = "http://bugs.adobe.com/jira/rpc/soap/jirasoapservice-v2?wsdl";
        model_internal::loadWSDLIfNecessary();
    }
    

    /**
      * This method is a generated wrapper used to call the 'getIssuesFromFilterWithLimit' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssuesFromFilterWithLimit(in0:String, in1:String, in2:int, in3:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssuesFromFilterWithLimit");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssuesFromJqlSearch' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssuesFromJqlSearch(in0:String, in1:String, in2:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssuesFromJqlSearch");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getVersions' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getVersions(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getVersions");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getConfiguration' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getConfiguration(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getConfiguration");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'progressWorkflowAction' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function progressWorkflowAction(in0:String, in1:String, in2:String, in3:ArrayCollection) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("progressWorkflowAction");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createProjectFromObject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createProjectFromObject(in0:String, in1:valueObjects.RemoteProject) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createProjectFromObject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getGroup' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getGroup(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getGroup");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addBase64EncodedAttachmentsToIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addBase64EncodedAttachmentsToIssue(in0:String, in1:String, in2:ArrayCollection, in3:ArrayCollection) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addBase64EncodedAttachmentsToIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateProject(in0:String, in1:valueObjects.RemoteProject) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addWorklogAndRetainRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addWorklogAndRetainRemainingEstimate(in0:String, in1:String, in2:valueObjects.RemoteWorklog) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addWorklogAndRetainRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteWorklogAndAutoAdjustRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteWorklogAndAutoAdjustRemainingEstimate(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteWorklogAndAutoAdjustRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteUser' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteUser(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteUser");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteProjectRole(in0:String, in1:valueObjects.RemoteProjectRole, in2:Boolean) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'removeAllRoleActorsByNameAndType' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function removeAllRoleActorsByNameAndType(in0:String, in1:String, in2:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("removeAllRoleActorsByNameAndType");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectByKey' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectByKey(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectByKey");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectsNoSchemes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectsNoSchemes(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectsNoSchemes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'setNewProjectAvatar' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function setNewProjectAvatar(in0:String, in1:String, in2:String, in3:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("setNewProjectAvatar");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssueTypesForProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssueTypesForProject(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssueTypesForProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getCustomFields' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getCustomFields(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getCustomFields");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'isProjectRoleNameUnique' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function isProjectRoleNameUnique(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("isProjectRoleNameUnique");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getDefaultRoleActors' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getDefaultRoleActors(in0:String, in1:valueObjects.RemoteProjectRole) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getDefaultRoleActors");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getComponents' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getComponents(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getComponents");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createPermissionScheme' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createPermissionScheme(in0:String, in1:String, in2:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createPermissionScheme");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getAssociatedPermissionSchemes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getAssociatedPermissionSchemes(in0:String, in1:valueObjects.RemoteProjectRole) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getAssociatedPermissionSchemes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectAvatars' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectAvatars(in0:String, in1:String, in2:Boolean) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectAvatars");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteWorklogWithNewRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteWorklogWithNewRemainingEstimate(in0:String, in1:String, in2:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteWorklogWithNewRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addVersion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addVersion(in0:String, in1:String, in2:valueObjects.RemoteVersion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addVersion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getSubTaskIssueTypesForProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getSubTaskIssueTypesForProject(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getSubTaskIssueTypesForProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getNotificationSchemes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getNotificationSchemes(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getNotificationSchemes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addAttachmentsToIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addAttachmentsToIssue(in0:String, in1:String, in2:ArrayCollection, in3:ArrayCollection) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addAttachmentsToIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'hasPermissionToDeleteWorklog' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function hasPermissionToDeleteWorklog(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("hasPermissionToDeleteWorklog");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'refreshCustomFields' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function refreshCustomFields(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("refreshCustomFields");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createProject(in0:String, in1:String, in2:String, in3:String, in4:String, in5:String, in6:valueObjects.RemotePermissionScheme, in7:valueObjects.RemoteScheme, in8:valueObjects.RemoteScheme) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3,in4,in5,in6,in7,in8) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateWorklogAndAutoAdjustRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateWorklogAndAutoAdjustRemainingEstimate(in0:String, in1:valueObjects.RemoteWorklog) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateWorklogAndAutoAdjustRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addWorklogWithNewRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addWorklogWithNewRemainingEstimate(in0:String, in1:String, in2:valueObjects.RemoteWorklog, in3:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addWorklogWithNewRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addPermissionTo' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addPermissionTo(in0:String, in1:valueObjects.RemotePermissionScheme, in2:valueObjects.RemotePermission, in3:valueObjects.RemoteEntity) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addPermissionTo");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateWorklogWithNewRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateWorklogWithNewRemainingEstimate(in0:String, in1:valueObjects.RemoteWorklog, in2:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateWorklogWithNewRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'login' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function login(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("login");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssuesFromTextSearchWithProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssuesFromTextSearchWithProject(in0:String, in1:ArrayCollection, in2:String, in3:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssuesFromTextSearchWithProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addComment' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addComment(in0:String, in1:String, in2:valueObjects.RemoteComment) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addComment");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getSubTaskIssueTypes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getSubTaskIssueTypes(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getSubTaskIssueTypes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssueTypes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssueTypes(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssueTypes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getFieldsForAction' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getFieldsForAction(in0:String, in1:String, in2:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getFieldsForAction");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectWithSchemesById' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectWithSchemesById(in0:String, in1:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectWithSchemesById");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getAvailableActions' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getAvailableActions(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getAvailableActions");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'removeUserFromGroup' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function removeUserFromGroup(in0:String, in1:valueObjects.RemoteGroup, in2:valueObjects.RemoteUser) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("removeUserFromGroup");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssuesFromFilter' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssuesFromFilter(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssuesFromFilter");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'setProjectAvatar' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function setProjectAvatar(in0:String, in1:String, in2:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("setProjectAvatar");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getSecurityLevels' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getSecurityLevels(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getSecurityLevels");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getResolutionDateById' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getResolutionDateById(in0:String, in1:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getResolutionDateById");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addUserToGroup' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addUserToGroup(in0:String, in1:valueObjects.RemoteGroup, in2:valueObjects.RemoteUser) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addUserToGroup");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectRole(in0:String, in1:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deletePermissionScheme' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deletePermissionScheme(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deletePermissionScheme");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createIssueWithSecurityLevel' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createIssueWithSecurityLevel(in0:String, in1:valueObjects.RemoteIssue, in2:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createIssueWithSecurityLevel");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssuesFromTextSearch' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssuesFromTextSearch(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssuesFromTextSearch");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getSavedFilters' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getSavedFilters(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getSavedFilters");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteIssue(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'hasPermissionToCreateWorklog' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function hasPermissionToCreateWorklog(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("hasPermissionToCreateWorklog");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'hasPermissionToUpdateWorklog' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function hasPermissionToUpdateWorklog(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("hasPermissionToUpdateWorklog");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addWorklogAndAutoAdjustRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addWorklogAndAutoAdjustRemainingEstimate(in0:String, in1:String, in2:valueObjects.RemoteWorklog) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addWorklogAndAutoAdjustRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectAvatar' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectAvatar(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectAvatar");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addActorsToProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addActorsToProjectRole(in0:String, in1:ArrayCollection, in2:valueObjects.RemoteProjectRole, in3:valueObjects.RemoteProject, in4:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addActorsToProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3,in4) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'logout' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function logout(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("logout");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getWorklogs' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getWorklogs(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getWorklogs");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectById' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectById(in0:String, in1:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectById");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getAllPermissions' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getAllPermissions(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getAllPermissions");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getFieldsForEdit' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getFieldsForEdit(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getFieldsForEdit");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createUser' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createUser(in0:String, in1:String, in2:String, in3:String, in4:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createUser");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3,in4) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'removeDefaultActorsFromProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function removeDefaultActorsFromProjectRole(in0:String, in1:ArrayCollection, in2:valueObjects.RemoteProjectRole, in3:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("removeDefaultActorsFromProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssue(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateProjectRole(in0:String, in1:valueObjects.RemoteProjectRole) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'archiveVersion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function archiveVersion(in0:String, in1:String, in2:String, in3:Boolean) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("archiveVersion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'removeActorsFromProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function removeActorsFromProjectRole(in0:String, in1:ArrayCollection, in2:valueObjects.RemoteProjectRole, in3:valueObjects.RemoteProject, in4:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("removeActorsFromProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3,in4) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectRoles' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectRoles(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectRoles");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateGroup' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateGroup(in0:String, in1:valueObjects.RemoteGroup) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateGroup");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getUser' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getUser(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getUser");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getAssociatedNotificationSchemes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getAssociatedNotificationSchemes(in0:String, in1:valueObjects.RemoteProjectRole) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getAssociatedNotificationSchemes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssueById' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssueById(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssueById");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteGroup' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteGroup(in0:String, in1:String, in2:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteGroup");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getFavouriteFilters' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getFavouriteFilters(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getFavouriteFilters");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getComments' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getComments(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getComments");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'addDefaultActorsToProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function addDefaultActorsToProjectRole(in0:String, in1:ArrayCollection, in2:valueObjects.RemoteProjectRole, in3:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("addDefaultActorsToProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createIssue(in0:String, in1:valueObjects.RemoteIssue) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getComment' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getComment(in0:String, in1:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getComment");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getSecurityLevel' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getSecurityLevel(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getSecurityLevel");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'removeAllRoleActorsByProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function removeAllRoleActorsByProject(in0:String, in1:valueObjects.RemoteProject) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("removeAllRoleActorsByProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getProjectRoleActors' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getProjectRoleActors(in0:String, in1:valueObjects.RemoteProjectRole, in2:valueObjects.RemoteProject) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getProjectRoleActors");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteProjectAvatar' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteProjectAvatar(in0:String, in1:Number) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteProjectAvatar");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'editComment' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function editComment(in0:String, in1:valueObjects.RemoteComment) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("editComment");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getPermissionSchemes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getPermissionSchemes(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getPermissionSchemes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'releaseVersion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function releaseVersion(in0:String, in1:String, in2:valueObjects.RemoteVersion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("releaseVersion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getPriorities' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getPriorities(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getPriorities");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createGroup' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createGroup(in0:String, in1:String, in2:valueObjects.RemoteUser) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createGroup");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateIssue(in0:String, in1:String, in2:ArrayCollection) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deletePermissionFrom' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deletePermissionFrom(in0:String, in1:valueObjects.RemotePermissionScheme, in2:valueObjects.RemotePermission, in3:valueObjects.RemoteEntity) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deletePermissionFrom");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssueCountForFilter' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssueCountForFilter(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssueCountForFilter");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteWorklogAndRetainRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteWorklogAndRetainRemainingEstimate(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteWorklogAndRetainRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getResolutionDateByKey' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getResolutionDateByKey(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getResolutionDateByKey");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getAttachmentsFromIssue' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getAttachmentsFromIssue(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getAttachmentsFromIssue");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'hasPermissionToEditComment' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function hasPermissionToEditComment(in0:String, in1:valueObjects.RemoteComment) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("hasPermissionToEditComment");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'updateWorklogAndRetainRemainingEstimate' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function updateWorklogAndRetainRemainingEstimate(in0:String, in1:valueObjects.RemoteWorklog) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("updateWorklogAndRetainRemainingEstimate");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getServerInfo' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getServerInfo(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getServerInfo");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'createProjectRole' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function createProjectRole(in0:String, in1:valueObjects.RemoteProjectRole) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("createProjectRole");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getIssuesFromTextSearchWithLimit' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getIssuesFromTextSearchWithLimit(in0:String, in1:String, in2:int, in3:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getIssuesFromTextSearchWithLimit");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1,in2,in3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getStatuses' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getStatuses(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getStatuses");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getSecuritySchemes' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getSecuritySchemes(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getSecuritySchemes");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getResolutions' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getResolutions(in0:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getResolutions");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'deleteProject' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function deleteProject(in0:String, in1:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("deleteProject");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(in0,in1) ;
        return _internal_token;
    }
     
}

}
